package com.aabte.commons.util;

import java.lang.annotation.Annotation;
import java.lang.reflect.*;
import java.util.*;
import java.util.Map.Entry;

/**
 * @author Daniel
 * @version 1.0
 * @date 2020/3/30
 */
public class ReflectionUtils {

    /**
     * 获取包名
     *
     * @return 包名【String类型】
     */
    public static String getPackage(Class<?> clazz) {
        Package pck = clazz.getPackage();
        if (null != pck) {
            return pck.getName();
        } else {
            return "";
        }
    }

    /**
     * 获取继承的父类的全类名
     *
     * @return 继承的父类的全类名【String类型】
     */
    public static String getSuperClassName(Class<?> clazz) {
        Class<?> superClass = clazz.getSuperclass();
        if (null != superClass) {
            return superClass.getName();
        } else {
            return "";
        }
    }

    /**
     * 获取全类名
     *
     * @return 全类名【String类型】
     */
    public static String getClassName(Class<?> clazz) {
        return clazz.getName();
    }

    /**
     * 获取实现的接口名
     *
     * @return 所有的接口名【每一个接口名的类型为String，最后保存到一个List集合中】
     */
    public static List<String> getInterfaces(Class<?> clazz) {
        Class<?>[] interfaces = clazz.getInterfaces();
        int len = interfaces.length;

        List<String> list = new ArrayList<>();
        for (Class<?> itfc : interfaces) {
            // 接口名
            String interfaceName = itfc.getSimpleName();

            list.add(interfaceName);
        }

        return list;
    }

    /**
     * 获取所有属性
     *
     * @return 所有的属性【每一个属性添加到StringBuilder中，最后保存到一个List集合中】
     */
    public static List<StringBuilder> getFields(Class<?> clazz) {
        Field[] fields = clazz.getDeclaredFields();
        return getFields(fields);
    }

    /**
     * 获取所有公共的属性
     *
     * @return 所有公共的属性【每一个属性添加到StringBuilder中，最后保存到一个List集合中】
     */
    public static List<StringBuilder> getPublicFields(Class<?> clazz) {
        Field[] fields = clazz.getFields();
        return getFields(fields);
    }

    private static List<StringBuilder> getFields(Field[] fields) {
        List<StringBuilder> list = new ArrayList<>();
        StringBuilder sb;
        for (Field field : fields) {
            sb = new StringBuilder();

            // 修饰符
            String modifier = Modifier.toString(field.getModifiers());
            sb.append(modifier).append(" ");

            // 数据类型
            Class<?> type = field.getType();
            String typeName = type.getSimpleName();
            sb.append(typeName).append(" ");

            // 属性名
            String fieldName = field.getName();
            sb.append(fieldName).append(";");

            list.add(sb);
        }

        return list;
    }

    /**
     * 获取所有构造方法
     *
     * @return 所有的构造方法【每一个构造方法添加到StringBuilder中，最后保存到一个List集合中】
     */
    public static List<StringBuilder> getConstructors(Class<?> clazz) {
        Constructor<?>[] constructors = clazz.getDeclaredConstructors();
        int len = constructors.length;

        List<StringBuilder> list = new ArrayList<>();
        StringBuilder sb;
        for (Constructor<?> constructor : constructors) {
            sb = new StringBuilder();

            // 修饰符
            String modifier = Modifier.toString(constructor.getModifiers());
            sb.append(modifier).append(" ");

            // 方法名（类名）
            String constructorName = clazz.getSimpleName();
            sb.append(constructorName).append(" (");

            // 形参列表
            Class<?>[] parameterTypes = constructor.getParameterTypes();
            int length = parameterTypes.length;
            for (int j = 0; j < length; j++) {
                Class<?> parameterType = parameterTypes[j];

                String parameterTypeName = parameterType.getSimpleName();

                if (j < length - 1) {
                    sb.append(parameterTypeName).append(", ");
                } else {
                    sb.append(parameterTypeName);
                }
            }

            sb.append(") {}");

            list.add(sb);
        }

        return list;
    }

    /**
     * 获取所有自身的方法
     *
     * @return 所有自身的方法【每一个方法添加到StringBuilder中，最后保存到一个List集合中】
     */
    public static List<StringBuilder> getMethods(Class<?> clazz) {
        Method[] methods = clazz.getDeclaredMethods();

        List<StringBuilder> list = new ArrayList<>();
        StringBuilder sb;
        for (Method method : methods) {
            sb = new StringBuilder();

            // 修饰符
            String modifier = Modifier.toString(method.getModifiers());
            sb.append(modifier).append(" ");

            // 返回值类型
            Class<?> returnClass = method.getReturnType();
            String returnType = returnClass.getSimpleName();
            sb.append(returnType).append(" ");

            // 方法名
            String methodName = method.getName();
            sb.append(methodName).append(" (");

            // 形参列表
            Class<?>[] parameterTypes = method.getParameterTypes();
            int length = parameterTypes.length;

            for (int j = 0; j < length; j++) {
                Class<?> parameterType = parameterTypes[j];

                // 形参类型
                String parameterTypeName = parameterType.getSimpleName();

                if (j < length - 1) {
                    sb.append(parameterTypeName).append(", ");
                } else {
                    sb.append(parameterTypeName);
                }
            }

            sb.append(") {}");

            list.add(sb);
        }

        return list;
    }

    /**
     * 获取所有公共的方法
     *
     * @return 所有公共的方法【每一个方法添加到StringBuilder中，最后保存到一个List集合中】
     */
    public static List<StringBuilder> getPublicMethods(Class<?> clazz) {
        Method[] methods = clazz.getMethods();

        List<StringBuilder> list = new ArrayList<>();
        StringBuilder sb;
        for (Method method : methods) {
            sb = new StringBuilder();

            // 修饰符
            String modifier = Modifier.toString(method.getModifiers());
            sb.append(modifier).append(" ");

            // 返回值类型
            Class<?> returnClass = method.getReturnType();
            String returnType = returnClass.getSimpleName();
            sb.append(returnType).append(" ");

            // 方法名
            String methodName = method.getName();
            sb.append(methodName).append(" (");

            // 形参列表
            Class<?>[] parameterTypes = method.getParameterTypes();
            int length = parameterTypes.length;

            for (int j = 0; j < length; j++) {
                Class<?> parameterType = parameterTypes[j];

                // 形参类型
                String parameterTypeName = parameterType.getSimpleName();

                if (j < length - 1) {
                    sb.append(parameterTypeName).append(", ");
                } else {
                    sb.append(parameterTypeName);
                }
            }

            sb.append(") {}");

            list.add(sb);
        }

        return list;
    }

    /**
     * 获取所有的注解名
     *
     * @return 所有的注解名【每一个注解名的类型为String，最后保存到一个List集合中】
     */
    public static List<String> getAnnotations(Class<?> clazz) {
        Annotation[] annotations = clazz.getAnnotations();
        int len = annotations.length;

        List<String> list = new ArrayList<>();
        for (Annotation annotation : annotations) {
            String annotationName = annotation.annotationType().getSimpleName();
            list.add(annotationName);
        }

        return list;
    }

    /**
     * 获取父类的泛型
     *
     * @return 父类的泛型【Class类型】
     */
    public static Class<?> getSuperClassGenericParameterizedType(Class<?> clazz) {
        Type genericSuperClass = clazz.getGenericSuperclass();

        Class<?> superClassGenericParameterizedType = null;

        // 判断父类是否有泛型
        if (genericSuperClass instanceof ParameterizedType) {
            // 向下转型，以便调用方法
            ParameterizedType pt = (ParameterizedType) genericSuperClass;
            // 只取第一个，因为一个类只能继承一个父类
            Type superClazz = pt.getActualTypeArguments()[0];
            // 转换为Class类型
            superClassGenericParameterizedType = (Class<?>) superClazz;
        }

        return superClassGenericParameterizedType;
    }

    /**
     * 获取接口的所有泛型
     *
     * @return 所有的泛型接口【每一个泛型接口的类型为Class，最后保存到一个List集合中】
     */
    public static List<Class<?>> getInterfaceGenericParameterizedTypes(Class<?> clazz) {
        Type[] genericInterfaces = clazz.getGenericInterfaces();

        List<Class<?>> list = new LinkedList<>();
        for (Type genericInterface : genericInterfaces) {
            // 判断接口是否有泛型
            if (genericInterface instanceof ParameterizedType) {
                ParameterizedType pt = (ParameterizedType) genericInterface;

                // 得到所有的泛型【Type类型的数组】
                Type[] interfaceTypes = pt.getActualTypeArguments();

                for (Type interfaceType : interfaceTypes) {
                    // 获取对应的泛型【Type类型】
                    // 转换为Class类型
                    Class<?> interfaceClass = (Class<?>) interfaceType;
                    list.add(interfaceClass);
                }
            }
        }

        return list;
    }

    /**
     * 获取父类的所有泛型，如果当前父类没有去父类的父类获取
     *
     * @return 父类的泛型【泛型父类的类型为Class，最后保存到一个List集合中】
     */
    public static List<Class<?>> getSuperclassGenericParameterizedTypes(Class<?> clazz) {
        if (null == clazz) {
            return Collections.emptyList();
        }

        Type genericSuperclass = clazz.getGenericSuperclass();

        List<Class<?>> list = new LinkedList<>();
        if (genericSuperclass instanceof ParameterizedType) {
            ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;
            Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                if (actualTypeArgument instanceof Class) {
                    Class<?> interfaceClass = (Class<?>) actualTypeArgument;
                    list.add(interfaceClass);
                }
            }
        } else {
            Class<?> superclass = clazz.getSuperclass();
            return getSuperclassGenericParameterizedTypes(superclass);
        }

        return list;
    }

    /**
     * 根据Class类型，获取对应的实例【要求必须有无参的构造器】
     *
     * @return 对应的实例【Object类型】
     */
    public static Object newInstance(Class<?> clazz)
            throws InstantiationException, IllegalAccessException {
        return clazz.newInstance();
    }

    /**
     * 根据传入的构造方法对象，以及，获取对应的实例
     *
     * @param constructor 构造方法对象
     * @param initargs    传入构造方法的实参【可以不写】
     * @return 对应的实例【Object类型】
     */
    public static Object newInstance(Constructor<?> constructor, Object... initargs)
            throws InstantiationException, IllegalAccessException, IllegalArgumentException,
            InvocationTargetException {
        constructor.setAccessible(true);
        return constructor.newInstance(initargs);
    }

    /**
     * 根据传入的类的Class对象，以及构造方法的形参的Class对象，获取对应的构造方法对象
     *
     * @param clazz          类的Class对象
     * @param parameterTypes 构造方法的形参的Class对象【可以不写】
     * @return 构造方法对象【Constructor类型】
     */
    public static Constructor<?> getConstructor(Class<?> clazz, Class<?>... parameterTypes)
            throws NoSuchMethodException, SecurityException {
        return clazz.getDeclaredConstructor(parameterTypes);
    }

    /**
     * 根据传入的属性名字符串，修改对应的属性值
     *
     * @param clazz 类的Class对象
     * @param name  属性名
     * @param obj   要修改的实例对象
     * @param value 修改后的新值
     */
    public static void setField(Class<?> clazz, String name, Object obj, Object value)
            throws NoSuchFieldException, SecurityException, IllegalArgumentException,
            IllegalAccessException {
        Field field = clazz.getDeclaredField(name);
        field.setAccessible(true);
        field.set(obj, value);
    }

    /**
     * 根据传入的方法名字符串，获取对应的方法
     *
     * @param clazz          类的Class对象
     * @param name           方法名
     * @param parameterTypes 方法的形参对应的Class类型【可以不写】
     * @return 方法对象【Method类型】
     */
    public static Method getMethod(Class<?> clazz, String name, Class<?>... parameterTypes)
            throws NoSuchMethodException, SecurityException {
        return clazz.getDeclaredMethod(name, parameterTypes);
    }

    /**
     * 根据传入的方法对象，调用对应的方法
     *
     * @param method 方法对象
     * @param obj    要调用的实例对象【如果是调用静态方法，则可以传入null】
     * @param args   传入方法的实参【可以不写】
     * @return 方法的返回值【没有返回值，则返回null】
     */
    public static Object invokeMethod(Method method, Object obj, Object... args)
            throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        method.setAccessible(true);
        return method.invoke(obj, args);
    }

    public static String getFieldNameByMethod(Method method) {
        String name = method.getName();
        boolean isFieldMethod = name.length() > 3 && (name.startsWith("set") || name.startsWith("get"));
        if (isFieldMethod) {
            String filedName = name.substring(3);
            return filedName.substring(0, 0).toLowerCase() + filedName.substring(1);
        }
        return null;
    }

    /**
     * 将POJO转换成Map
     */
    public static Map<String, Object> toMap(Object obj)
            throws IllegalArgumentException, InvocationTargetException, IllegalAccessException {
        if (null == obj) {
            throw new IllegalArgumentException("obj cannot be null");
        }
        Class<?> clazz = obj.getClass();

        boolean basicType = isBasicType(clazz);
        if (basicType) {
            throw new IllegalArgumentException("obj is basic type");
        }

        if (clazz.equals(Object.class)) {
            return new HashMap<>(0);
        }

        if (Map.class.isAssignableFrom(clazz)) {
            Map map = (Map) obj;
            Class<?> genericParameterizedType = getSuperClassGenericParameterizedType(clazz);
            if (genericParameterizedType.equals(String.class)) {
                return (Map<String, Object>) map;
            } else {
                Map<String, Object> result = new HashMap<>(map.size());
                Set<Map.Entry> set = map.entrySet();
                for (Entry entry : set) {
                    result.put(entry.getKey().toString(), entry.getValue());
                }
                return result;
            }
        }

        Method[] declaredMethods = clazz.getDeclaredMethods();
        Map<String, Object> result = new HashMap<>(declaredMethods.length / 2);
        for (Method method : declaredMethods) {
            String methodName = method.getName();
            Class<?>[] parameterTypes = method.getParameterTypes();
            if (parameterTypes.length == 0 && methodName.length() > 3 && methodName.startsWith("get")) {
                Object fieldValue = invokeMethod(method, obj);
                result.put(methodName.substring(3), fieldValue);
            }
        }
        return result;
    }

    public static boolean isBasicType(Class<?> clazz) {
        return isPrimitive(clazz) || isPackageType(clazz);
    }

    public static boolean isPackageType(Class<?> clazz) {
        return clazz.equals(Boolean.class)
                || clazz.equals(Character.class)
                || clazz.equals(Byte.class)
                || clazz.equals(Short.class)
                || clazz.equals(Integer.class)
                || clazz.equals(Long.class)
                || clazz.equals(Float.class)
                || clazz.equals(Double.class)
                || clazz.equals(Void.class);
    }

    public static boolean isPrimitive(Object obj) {
        if (null == obj) {
            throw new IllegalArgumentException("obj cannot be null");
        }
        Class<?> clazz = obj.getClass();
        return clazz.isPrimitive();
    }
}
